time/[root]/TimePeriod

TimePeriod

data class TimePeriod<SmallestUnit : TimeUnit> : Comparable<TimePeriod<SmallestUnit>>

Types

Companion

object Companion

Functions

applying

fun <DifferenceUnit : TimeUnit> applying(difference: TimeDifference<DifferenceUnit>): TimePeriod<SmallestUnit>

compareTo

open operator override fun compareTo(other: TimePeriod<SmallestUnit>): Int

toString

open override fun toString(): String

Properties

firstInstant

val firstInstant: Instant

lastInstant

val ~~lastInstant~~: Instant

range

val range: ClosedRange<Instant>

Retrieve the range of Instants described by this TimePeriod.

timeZone

val timeZone: TimeZone

Extensions

addingDays

fun <Unit : DayOrSmaller, TimeUnit> TimePeriod<Unit>.addingDays(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving forward some number of days.

addingHours

fun <Unit : HourOrSmaller, TimeUnit> TimePeriod<Unit>.addingHours(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving forward some number of hours.

addingMinutes

fun <Unit : MinuteOrSmaller, TimeUnit> TimePeriod<Unit>.addingMinutes(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving forward some number of minutes.

addingMonths

fun <Unit : MonthOrSmaller, TimeUnit> TimePeriod<Unit>.addingMonths(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving forward some number of months.

addingNanoseconds

fun <Unit : NanosecondOrSmaller, TimeUnit> TimePeriod<Unit>.addingNanoseconds(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving forward some number of nanoseconds.

addingSeconds

fun <Unit : SecondOrSmaller, TimeUnit> TimePeriod<Unit>.addingSeconds(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving forward some number of seconds.

addingYears

fun <Unit : YearOrSmaller, TimeUnit> TimePeriod<Unit>.addingYears(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving forward some number of years.

after

fun TimePeriod<*>.after(other: TimePeriod<*>): Boolean

before

fun TimePeriod<*>.before(other: TimePeriod<*>): Boolean

contains

fun TimePeriod<*>.contains(other: TimePeriod<*>): Boolean

convertToTimeZone

fun <Unit : TimeUnit> TimePeriod<Unit>.convertToTimeZone(timeZone: TimeZone): TimePeriod<Unit>

Construct a new TimePeriod by converting the receiver to a new TimeZone.

dayOfMonth

val <Unit : DayOrSmaller, TimeUnit> TimePeriod<Unit>.dayOfMonth: Int

dayOfWeek

val <Unit : DayOrSmaller, TimeUnit> TimePeriod<Unit>.dayOfWeek: DayOfWeek

dayOfYear

val <Unit : DayOrSmaller, TimeUnit> TimePeriod<Unit>.dayOfYear: Int

dayPeriod

val <Unit : HourOrSmaller, TimeUnit> TimePeriod<Unit>.dayPeriod: TimePeriod<TimeUnit.Day>

days

@get:JvmName(name = "monthDays")

val TimePeriod<TimeUnit.Month>.days: Sequence<TimePeriod<TimeUnit.Day>>

@get:JvmName(name = "yearDays")

val TimePeriod<TimeUnit.Year>.days: Sequence<TimePeriod<TimeUnit.Day>>

during

fun TimePeriod<*>.during(other: TimePeriod<*>): Boolean

firstDay

@get:JvmName(name = "yearFirstDay")

val TimePeriod<TimeUnit.Year>.firstDay: TimePeriod<TimeUnit.Day>

@get:JvmName(name = "monthFirstDay")

val TimePeriod<TimeUnit.Month>.firstDay: TimePeriod<TimeUnit.Day>

firstHour

@get:JvmName(name = "monthFirstHour")

val TimePeriod<TimeUnit.Month>.firstHour: TimePeriod<TimeUnit.Hour>

@get:JvmName(name = "dayFirstHour")

val TimePeriod<TimeUnit.Day>.firstHour: TimePeriod<TimeUnit.Hour>

firstMinute

@get:JvmName(name = "dayFirstMinute")

val TimePeriod<TimeUnit.Day>.firstMinute: TimePeriod<TimeUnit.Minute>

@get:JvmName(name = "hourFirstMinute")

val TimePeriod<TimeUnit.Hour>.firstMinute: TimePeriod<TimeUnit.Minute>

firstMonth

val TimePeriod<TimeUnit.Year>.firstMonth: TimePeriod<TimeUnit.Month>

firstSecond

@get:JvmName(name = "dayFirstSecond")

val TimePeriod<TimeUnit.Day>.firstSecond: TimePeriod<TimeUnit.Second>

@get:JvmName(name = "hourFirstSecond")

val TimePeriod<TimeUnit.Hour>.firstSecond: TimePeriod<TimeUnit.Second>

@get:JvmName(name = "minuteFirstSecond")

val TimePeriod<TimeUnit.Minute>.firstSecond: TimePeriod<TimeUnit.Second>

hour

val <Unit : HourOrSmaller, TimeUnit> TimePeriod<Unit>.hour: Int

hourPeriod

val <Unit : MinuteOrSmaller, TimeUnit> TimePeriod<Unit>.hourPeriod: TimePeriod<TimeUnit.Hour>

hours

@get:JvmName(name = "dayHours")

val TimePeriod<TimeUnit.Day>.hours: Sequence<TimePeriod<TimeUnit.Hour>>

@get:JvmName(name = "monthHours")

val TimePeriod<TimeUnit.Month>.hours: Sequence<TimePeriod<TimeUnit.Hour>>

lastDay

@get:JvmName(name = "yearLastDay")

val TimePeriod<TimeUnit.Year>.lastDay: TimePeriod<TimeUnit.Day>

@get:JvmName(name = "monthLastDay")

val TimePeriod<TimeUnit.Month>.lastDay: TimePeriod<TimeUnit.Day>

lastHour

@get:JvmName(name = "monthLastHour")

val TimePeriod<TimeUnit.Month>.lastHour: TimePeriod<TimeUnit.Hour>

@get:JvmName(name = "dayLastHour")

val TimePeriod<TimeUnit.Day>.lastHour: TimePeriod<TimeUnit.Hour>

lastMinute

@get:JvmName(name = "dayLastMinute")

val TimePeriod<TimeUnit.Day>.lastMinute: TimePeriod<TimeUnit.Minute>

@get:JvmName(name = "hourLastMinute")

val TimePeriod<TimeUnit.Hour>.lastMinute: TimePeriod<TimeUnit.Minute>

lastMonth

val TimePeriod<TimeUnit.Year>.lastMonth: TimePeriod<TimeUnit.Month>

lastSecond

@get:JvmName(name = "dayLastSecond")

val TimePeriod<TimeUnit.Day>.lastSecond: TimePeriod<TimeUnit.Second>

@get:JvmName(name = "hourLastSecond")

val TimePeriod<TimeUnit.Hour>.lastSecond: TimePeriod<TimeUnit.Second>

@get:JvmName(name = "minuteLastSecond")

val TimePeriod<TimeUnit.Minute>.lastSecond: TimePeriod<TimeUnit.Second>

minus

operator fun <Unit : TimeUnit> TimePeriod<Unit>.minus(difference: TimeDifference<Unit>): TimePeriod<Unit>

Subtracts a TimeDifference from this TimePeriod.

minute

val <Unit : MinuteOrSmaller, TimeUnit> TimePeriod<Unit>.minute: Int

minutePeriod

val <Unit : SecondOrSmaller, TimeUnit> TimePeriod<Unit>.minutePeriod: TimePeriod<TimeUnit.Minute>

minutes

@get:JvmName(name = "hourMinutes")

val TimePeriod<TimeUnit.Hour>.minutes: Sequence<TimePeriod<TimeUnit.Minute>>

@get:JvmName(name = "dayMinutes")

val TimePeriod<TimeUnit.Day>.minutes: Sequence<TimePeriod<TimeUnit.Minute>>

month

val <Unit : MonthOrSmaller, TimeUnit> TimePeriod<Unit>.month: Month

monthPeriod

val <Unit : DayOrSmaller, TimeUnit> TimePeriod<Unit>.monthPeriod: TimePeriod<TimeUnit.Month>

months

val TimePeriod<TimeUnit.Year>.months: Sequence<TimePeriod<TimeUnit.Month>>

nanosecond

val <Unit : NanosecondOrSmaller, TimeUnit> TimePeriod<Unit>.nanosecond: Int

nextDay

val <Unit : DayOrSmaller, TimeUnit> TimePeriod<Unit>.nextDay: TimePeriod<Unit>

Create a new TimePeriod by moving forward one day.

nextHour

val <Unit : HourOrSmaller, TimeUnit> TimePeriod<Unit>.nextHour: TimePeriod<Unit>

Create a new TimePeriod by moving forward one hour.

nextMinute

val <Unit : MinuteOrSmaller, TimeUnit> TimePeriod<Unit>.nextMinute: TimePeriod<Unit>

Create a new TimePeriod by moving forward one minute.

nextMonth

val <Unit : MonthOrSmaller, TimeUnit> TimePeriod<Unit>.nextMonth: TimePeriod<Unit>

Create a new TimePeriod by moving forward one month.

nextNanosecond

val <Unit : NanosecondOrSmaller, TimeUnit> TimePeriod<Unit>.nextNanosecond: TimePeriod<Unit>

Create a new TimePeriod by moving forward one nanosecond.

nextSecond

val <Unit : SecondOrSmaller, TimeUnit> TimePeriod<Unit>.nextSecond: TimePeriod<Unit>

Create a new TimePeriod by moving forward one second.

nextYear

val <Unit : YearOrSmaller, TimeUnit> TimePeriod<Unit>.nextYear: TimePeriod<Unit>

Create a new TimePeriod by moving forward one year.

offset

fun <Unit : TimeUnit> TimePeriod<Unit>.offset(count: Int): TimePeriod<Unit>

overlaps

fun TimePeriod<*>.overlaps(other: TimePeriod<*>): Boolean

plus

operator fun <Unit : TimeUnit> TimePeriod<Unit>.plus(difference: TimeDifference<Unit>): TimePeriod<Unit>

Adds a TimeDifference to this TimePeriod.

previousDay

val <Unit : DayOrSmaller, TimeUnit> TimePeriod<Unit>.previousDay: TimePeriod<Unit>

Create a new TimePeriod by moving backward one day.

previousHour

val <Unit : HourOrSmaller, TimeUnit> TimePeriod<Unit>.previousHour: TimePeriod<Unit>

Create a new TimePeriod by moving backward one hour.

previousMinute

val <Unit : MinuteOrSmaller, TimeUnit> TimePeriod<Unit>.previousMinute: TimePeriod<Unit>

Create a new TimePeriod by moving backward one minute.

previousMonth

val <Unit : MonthOrSmaller, TimeUnit> TimePeriod<Unit>.previousMonth: TimePeriod<Unit>

Create a new TimePeriod by moving backward one month.

previousNanosecond

val <Unit : NanosecondOrSmaller, TimeUnit> TimePeriod<Unit>.previousNanosecond: TimePeriod<Unit>

Create a new TimePeriod by moving backward one nanosecond.

previousSecond

val <Unit : SecondOrSmaller, TimeUnit> TimePeriod<Unit>.previousSecond: TimePeriod<Unit>

Create a new TimePeriod by moving backward one second.

previousYear

val <Unit : YearOrSmaller, TimeUnit> TimePeriod<Unit>.previousYear: TimePeriod<Unit>

Create a new TimePeriod by moving backward one year.

relation

fun TimePeriod<*>.relation(other: TimePeriod<*>): Relation

second

val <Unit : SecondOrSmaller, TimeUnit> TimePeriod<Unit>.second: Int

secondPeriod

val <Unit : NanosecondOrSmaller, TimeUnit> TimePeriod<Unit>.secondPeriod: TimePeriod<TimeUnit.Second>

seconds

@get:JvmName(name = "minuteSeconds")

val TimePeriod<TimeUnit.Minute>.seconds: Sequence<TimePeriod<TimeUnit.Second>>

@get:JvmName(name = "hourSeconds")

val TimePeriod<TimeUnit.Hour>.seconds: Sequence<TimePeriod<TimeUnit.Second>>

subtractingDays

fun <Unit : DayOrSmaller, TimeUnit> TimePeriod<Unit>.subtractingDays(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving backward some number of days.

subtractingHours

fun <Unit : HourOrSmaller, TimeUnit> TimePeriod<Unit>.subtractingHours(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving backward some number of hours.

subtractingMinutes

fun <Unit : MinuteOrSmaller, TimeUnit> TimePeriod<Unit>.subtractingMinutes(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving backward some number of minutes.

subtractingMonths

fun <Unit : MonthOrSmaller, TimeUnit> TimePeriod<Unit>.subtractingMonths(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving backward some number of months.

subtractingNanoseconds

fun <Unit : NanosecondOrSmaller, TimeUnit> TimePeriod<Unit>.subtractingNanoseconds(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving backward some number of nanoseconds.

subtractingSeconds

fun <Unit : SecondOrSmaller, TimeUnit> TimePeriod<Unit>.subtractingSeconds(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving backward some number of seconds.

subtractingYears

fun <Unit : YearOrSmaller, TimeUnit> TimePeriod<Unit>.subtractingYears(count: Int): TimePeriod<Unit>

Create a new TimePeriod by moving backward some number of years.

toLocalDate

fun <Unit : TimeUnit, DayOrSmaller> TimePeriod<Unit>.toLocalDate(): LocalDate

Constructs a kotlinx.datetime.LocalDate from a TimePeriod with Day or finer precision.

toLocalDateTime

fun <Unit : TimeUnit, HourOrSmaller> TimePeriod<Unit>.toLocalDateTime(): LocalDateTime

Constructs a kotlinx.datetime.LocalDateTime from a TimePeriod with Hour or smaller precision.

year

val <Unit : YearOrSmaller, TimeUnit> TimePeriod<Unit>.year: Int

yearPeriod

val <Unit : MonthOrSmaller, TimeUnit> TimePeriod<Unit>.yearPeriod: TimePeriod<TimeUnit.Year>